@servicenow/sdk-build-plugins 4.6.0 → 4.7.0

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

@@ -21,6 +21,9 @@ import {
     BUILT_IN_STEP_DEFINITIONS,
     BUILT_IN_STEP_NAME_TO_SYSID,
     BUILT_IN_STEP_PREFIX,
+    STEP_DEF_INPUT_TABLE_PREFIX,
+    EXT_INPUT_TABLE_PREFIX,
+    EXT_OUTPUT_TABLE_PREFIX,
     buildExtVarAttributes,
     getVarEntryName,
     getVarEntryType,
@@ -28,8 +31,8 @@ import {
     FLOW_ARRAY_API_NAME,
 } from '../utils/flow-constants'
 import { normalizeInputValue } from './flow-instance-plugin'
+import { stripPillType, collectPillTypes } from '../utils/flow-pill-utils'
 import { ApprovalRulesShape, ApprovalDueDateShape } from '../utils/flow-shapes'
-import { createSdkDocEntry } from '../../utils'
 import {
     generateSchemaFromObject,
     getComplexObjectAttributes,
@@ -123,42 +126,7 @@ function resolveFieldToPillString(fieldShape: Shape, cidMap?: Map<string, string
     return undefined
 }
 
-/**
- * Extracts pill type annotations from a pill string and stores them in the pillTypeMap.
- * Captures types from both step pills ({{step[CID].path|type}}) and action pills
- * ({{action.path|type}}). The "|type" portion is captured before it gets stripped
- * for the element_mapping value. The collected types are used later when building the label_cache.
- */
-const STEP_PILL_TYPE_REGEX = /\{\{step\[([^\]]+)\]\.([^|}]+)(?:\|([^}]+))?\}\}/g
-const ACTION_PILL_TYPE_REGEX = /\{\{action\.([^|}]+)(?:\|([^}]+))?\}\}/g
-function collectPillTypes(pillString: string, pillTypeMap?: Map<string, string>): void {
-    if (!pillTypeMap) {
-        return
-    }
-    for (const match of pillString.matchAll(STEP_PILL_TYPE_REGEX)) {
-        const [, cid, pillPath, dataType] = match
-        if (cid && pillPath && dataType) {
-            pillTypeMap.set(`${cid}::${pillPath}`, dataType)
-        }
-    }
-    for (const match of pillString.matchAll(ACTION_PILL_TYPE_REGEX)) {
-        const [, path, dataType] = match
-        if (path && dataType) {
-            pillTypeMap.set(`action::${path}`, dataType)
-        }
-    }
-}
-
-/**
- * Strips the |type suffix from a pill string.
- * e.g., "{{action.desc|string}}" → "{{action.desc}}"
- *
- * Note: This is called on individual pill strings (from resolveFieldToPillString),
- * never on concatenated multi-pill strings — so no `g` flag is needed.
- */
-function stripPillType(pill: string): string {
-    return pill.replace(/\|[^}]+/, '')
-}
+// stripPillType, collectPillTypes, and STEP_PILL_TYPE_REGEX are imported from ../utils/flow-pill-utils
 
 /**
  * Resolves a TemplateExpressionShape into a concatenated string, replacing
@@ -266,7 +234,6 @@ export class StepInstanceShape extends CallExpressionShape {
 
 export const StepInstancePlugin = Plugin.create({
     name: 'StepInstancePlugin',
-    docs: [createSdkDocEntry('wfa.actionStep', ['sys_hub_step_instance'])],
     shapes: [
         {
             shape: CallExpressionShape,
@@ -368,9 +335,11 @@ export const StepInstancePlugin = Plugin.create({
                     ...(inputDefinitions ? { inputDefinitions } : {}),
                 }
 
+                const newShape = new StepInstanceShape(shapeArgs)
+
                 return {
                     success: true,
-                    value: new StepInstanceShape(shapeArgs),
+                    value: newShape,
                 }
             },
         },
@@ -624,7 +593,7 @@ async function buildStepInstanceRecord({
         const inputVarObj = inputVariablesShape.asObject()
         const inputVarProps = inputVarObj.properties({ resolve: false })
 
-        const extInputTableName = `var__m_sys_hub_step_ext_input_${stepInstanceSysId}`
+        const extInputTableName = `${EXT_INPUT_TABLE_PREFIX}${stepInstanceSysId}`
 
         for (const [name, configShapeRaw] of Object.entries(inputVarProps)) {
             const configObj = configShapeRaw.asObject()
@@ -799,7 +768,7 @@ async function buildStepInstanceRecord({
                         model: stepInstanceSysId,
                         model_id: stepInstanceSysId,
                         model_table: 'sys_hub_step_instance',
-                        name: `var__m_sys_hub_step_ext_output_${stepInstanceSysId}`,
+                        name: `${EXT_OUTPUT_TABLE_PREFIX}${stepInstanceSysId}`,
                         element: columnName,
                         label: columnLabel || columnName,
                         internal_type: 'string',
@@ -823,7 +792,7 @@ async function buildStepInstanceRecord({
                         model: stepInstanceSysId,
                         model_id: stepInstanceSysId,
                         model_table: 'sys_hub_step_instance',
-                        name: `var__m_sys_hub_step_ext_output_${stepInstanceSysId}`,
+                        name: `${EXT_OUTPUT_TABLE_PREFIX}${stepInstanceSysId}`,
                         element: columnName,
                         label: columnLabel || columnName,
                         internal_type: internalType,
@@ -847,6 +816,165 @@ async function buildStepInstanceRecord({
         ...complexObjectRecords
     )
 }
+/**
+ * Resolves datapill shapes (CallExpressionShape from wfa.dataPill()) inside an ApprovalRulesShape
+ * back to pill strings (e.g. {{action.reference}}) so approvalRulesJsonToString() can serialize them.
+ * Also collects pill types for label_cache and reports whether any pills were found.
+ *
+ * IMPORTANT: Must use Shape API with resolve=false to access raw CallExpressionShape instances.
+ * getApprovalRules()/getValue() resolves shapes to Symbols, losing the pill information.
+ */
+function resolveApprovalRulesPills(
+    shape: ApprovalRulesShape,
+    callExpression: { getSource(): Source },
+    cidMap?: Map<string, string>,
+    pillTypeMap?: Map<string, string>
+): { resolvedShape: ApprovalRulesShape; hasPills: boolean } {
+    // Get the resolved rules data (non-pill fields resolve to plain values correctly)
+    const rules = shape.getApprovalRules()
+    let hasPills = false
+
+    // Walk the raw Shape tree in parallel to find unresolved CallExpressionShape pills.
+    // shape.get('ruleSets', false) returns the raw ArrayShape without resolving nested shapes.
+    const ruleSetsShape = shape.get('ruleSets', false).ifArray()
+    if (!ruleSetsShape) {
+        return { resolvedShape: shape, hasPills: false }
+    }
+
+    ruleSetsShape.getElements(false).forEach((ruleSetShape, rsIdx) => {
+        const ruleSetObj = ruleSetShape.ifObject()
+        const rulesArrayShape = ruleSetObj?.get('rules', false).ifArray()
+
+        rulesArrayShape?.getElements(false).forEach((ruleShape, rIdx) => {
+            const ruleArray = ruleShape.ifArray()
+
+            ruleArray?.getElements(false).forEach((conditionShape, cIdx) => {
+                const conditionObj = conditionShape.ifObject()
+                if (!conditionObj) {
+                    return
+                }
+
+                const ruleSet = rules.ruleSets?.[rsIdx]
+                const rule = ruleSet?.rules?.[rIdx]
+                const condition = rule?.[cIdx]
+                if (!condition) {
+                    return
+                }
+
+                // Resolve pills in users array
+                conditionObj
+                    .get('users', false)
+                    .ifArray()
+                    ?.getElements(false)
+                    .forEach((userShape, uIdx) => {
+                        const pillStr = resolveShapeToPill(userShape, cidMap, pillTypeMap)
+                        if (pillStr && condition.users) {
+                            hasPills = true
+                            condition.users[uIdx] = pillStr
+                        }
+                    })
+
+                // Resolve pills in groups array
+                conditionObj
+                    .get('groups', false)
+                    .ifArray()
+                    ?.getElements(false)
+                    .forEach((groupShape, gIdx) => {
+                        const pillStr = resolveShapeToPill(groupShape, cidMap, pillTypeMap)
+                        if (pillStr && condition.groups) {
+                            hasPills = true
+                            condition.groups[gIdx] = pillStr
+                        }
+                    })
+            })
+        })
+    })
+
+    if (!hasPills) {
+        return { resolvedShape: shape, hasPills: false }
+    }
+
+    return {
+        resolvedShape: new ApprovalRulesShape({
+            source: callExpression.getSource(),
+            value: rules,
+        }),
+        hasPills: true,
+    }
+}
+
+/**
+ * Resolves datapill shapes (CallExpressionShape from wfa.dataPill()) inside an ApprovalDueDateShape
+ * back to pill strings (e.g. {{action.date}}) so the JSON serialization produces correct output.
+ *
+ * IMPORTANT: Must use shape.get('date', false) to access the raw Shape. getApprovalDueDate()
+ * calls getValue() which resolves CallExpressionShape to Symbol, losing the pill information.
+ */
+function resolveApprovalDueDatePills(
+    shape: ApprovalDueDateShape,
+    callExpression: { getSource(): Source },
+    cidMap?: Map<string, string>,
+    pillTypeMap?: Map<string, string>
+): ApprovalDueDateShape {
+    // Access 'date' as raw Shape (not resolved via getValue())
+    const dateShape = shape.get('date', false)
+    const pillStr = resolveShapeToPill(dateShape, cidMap, pillTypeMap)
+    if (!pillStr) {
+        // Unresolvable pill (e.g. step pill when cidMap is not yet populated).
+        // Return original shape — resolveUnresolvedStepPills() will handle it later.
+        return shape
+    }
+
+    // Get all other resolved values and override date with the pill string
+    const dueDate = shape.getApprovalDueDate()
+    return new ApprovalDueDateShape({
+        source: callExpression.getSource(),
+        value: { ...dueDate, date: pillStr },
+    })
+}
+
+/**
+ * If `shape` is a datapill (CallExpressionShape with callee wfa.dataPill, or PillShape),
+ * resolves it to a pill string (e.g. {{action.reference}}), strips the type suffix,
+ * collects pill types for label_cache, and returns the stripped string.
+ * Returns undefined if the shape is not a pill.
+ */
+function resolveShapeToPill(
+    shape: Shape,
+    cidMap?: Map<string, string>,
+    pillTypeMap?: Map<string, string>
+): string | undefined {
+    const pillString = resolveFieldToPillString(shape, cidMap)
+    if (!pillString) {
+        return undefined
+    }
+    collectPillTypes(pillString, pillTypeMap)
+    return stripPillType(pillString)
+}
+
+/**
+ * Checks if a wfa.dataPill() CallExpressionShape is an action pill (params.inputs.*).
+ * Used to distinguish action pills from step pills when deciding whether to defer resolution.
+ */
+function isActionPillShape(shape: CallExpressionShape): boolean {
+    const expressionArg = shape.getArgument(0, false)
+    if (!(expressionArg instanceof PropertyAccessShape)) {
+        return false
+    }
+    const elements = expressionArg.getElements()
+    if (elements.length < 3) {
+        return false
+    }
+    const first = elements[0]
+    const second = elements[1]
+    return (
+        first instanceof IdentifierShape &&
+        first.getName() === 'params' &&
+        second instanceof IdentifierShape &&
+        second.getName() === 'inputs'
+    )
+}
+
 async function createVariableRecords(
     valuesProperties: globalThis.Record<string, Shape>,
     inputs: ObjectShape | undefined,
@@ -890,19 +1018,47 @@ async function createVariableRecords(
             // ApprovalDueDateShape: store JSON in sys_element_mapping.value (ServiceNow reads from there)
             // and create sys_variable_value with empty value
             if (valueShape.is(ApprovalDueDateShape)) {
-                const jsonValue = (valueShape as ApprovalDueDateShape).toString().getValue()
-                const [elementMappingRecord, variableValueRecord] = await Promise.all([
-                    factory.createRecord({
-                        source: callExpression,
-                        table: 'sys_element_mapping',
-                        properties: {
-                            field: key,
-                            id: stepInstanceSysId,
-                            table: `var__m_sys_flow_step_definition_input_${stepDefinitionSysId}`,
-                            value: jsonValue,
-                        },
-                    }),
-                    factory.createRecord({
+                // Resolve any datapill shapes (e.g. wfa.dataPill()) inside the due date
+                // back to pill strings (e.g. {{action.date}}) before serialization
+                const resolvedDueDateShape = resolveApprovalDueDatePills(
+                    valueShape as ApprovalDueDateShape,
+                    callExpression,
+                    cidMap,
+                    pillTypeMap
+                )
+
+                // Check if date contains an unresolved step pill. During initial auto-processing
+                // (inside transform.toShape), cidMap is not yet populated so step pills can't be
+                // resolved. In that case, skip element_mapping creation here —
+                // resolveUnresolvedStepPills() in flow-action-definition-plugin will create it
+                // once cidMap is fully built.
+                const dateShape = (valueShape as ApprovalDueDateShape).get('date', false)
+                const hasUnresolvedStepPill =
+                    dateShape instanceof CallExpressionShape &&
+                    dateShape.getCallee() === 'wfa.dataPill' &&
+                    !isActionPillShape(dateShape) &&
+                    !resolveShapeToPill(dateShape, cidMap, pillTypeMap)
+
+                const records: BuildRecord[] = []
+
+                if (!hasUnresolvedStepPill) {
+                    const jsonValue = resolvedDueDateShape.toString().getValue()
+                    records.push(
+                        await factory.createRecord({
+                            source: callExpression,
+                            table: 'sys_element_mapping',
+                            properties: {
+                                field: key,
+                                id: stepInstanceSysId,
+                                table: `${STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`,
+                                value: jsonValue,
+                            },
+                        })
+                    )
+                }
+
+                records.push(
+                    await factory.createRecord({
                         source: callExpression,
                         table: 'sys_variable_value',
                         properties: {
@@ -913,9 +1069,10 @@ async function createVariableRecords(
                             value: '',
                             variable: variableSysId,
                         },
-                    }),
-                ])
-                allRecords.push(elementMappingRecord, variableValueRecord)
+                    })
+                )
+
+                allRecords.push(...records)
                 return
             }
 
@@ -964,7 +1121,7 @@ async function createVariableRecords(
                             properties: {
                                 field: key,
                                 id: stepInstanceSysId,
-                                table: `var__m_sys_flow_step_definition_input_${stepDefinitionSysId}`,
+                                table: `${STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`,
                                 value: encodedValue,
                             },
                         })
@@ -978,10 +1135,47 @@ async function createVariableRecords(
                 // DurationShape.getValue() returns a symbol, so use toString() instead
                 actualValue = (valueShape as DurationShape).toString().getValue()
             } else if (valueShape.is(ApprovalRulesShape)) {
-                // ApprovalRulesShape.getValue() returns a JSON object, not a string.
-                // Previously fell through to the generic getValue() path which stored a raw [object Object].
-                // toString() correctly serializes it to the JSON string ServiceNow expects.
-                actualValue = valueShape.toString().getValue()
+                // Resolve any datapill shapes (e.g. wfa.dataPill()) inside approval rules
+                // back to pill strings (e.g. {{action.reference}}) before serialization
+                const { resolvedShape: resolvedRulesShape, hasPills: rulesHasPills } = resolveApprovalRulesPills(
+                    valueShape as ApprovalRulesShape,
+                    callExpression,
+                    cidMap,
+                    pillTypeMap
+                )
+                const serializedRules = resolvedRulesShape.toString().getValue()
+
+                if (rulesHasPills) {
+                    // Pills found — store in sys_element_mapping (platform reads pills from there)
+                    // and create empty sys_variable_value (same pattern as ApprovalDueDateShape)
+                    const [elementMappingRecord, variableValueRecord] = await Promise.all([
+                        factory.createRecord({
+                            source: callExpression,
+                            table: 'sys_element_mapping',
+                            properties: {
+                                field: key,
+                                id: stepInstanceSysId,
+                                table: `${STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`,
+                                value: serializedRules,
+                            },
+                        }),
+                        factory.createRecord({
+                            source: callExpression,
+                            table: 'sys_variable_value',
+                            properties: {
+                                document: 'sys_hub_step_instance',
+                                document_key: stepInstanceSysId,
+                                order: 100,
+                                value: '',
+                                variable: variableSysId,
+                            },
+                        }),
+                    ])
+                    allRecords.push(elementMappingRecord, variableValueRecord)
+                    return
+                }
+
+                actualValue = serializedRules
             } else if (valueShape.is(TemplateExpressionShape)) {
                 const { result, hasPills } = resolveTemplateExpression(
                     valueShape as TemplateExpressionShape,
@@ -996,7 +1190,7 @@ async function createVariableRecords(
                             properties: {
                                 field: key,
                                 id: stepInstanceSysId,
-                                table: `var__m_sys_flow_step_definition_input_${stepDefinitionSysId}`,
+                                table: `${STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`,
                                 value: result,
                             },
                         })
@@ -1017,7 +1211,7 @@ async function createVariableRecords(
                             properties: {
                                 field: key,
                                 id: stepInstanceSysId,
-                                table: `var__m_sys_flow_step_definition_input_${stepDefinitionSysId}`,
+                                table: `${STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`,
                                 value: stripPillType(pillString),
                             },
                         })

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

@@ -1,11 +1,9 @@
 import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
 import { buildVariableShapes, complexObjectMatchesIoRecord } from '../utils/flow-io-to-record'
 import { NowIdShape } from '../../now-id-plugin'
-import { createSdkDocEntry } from '../../utils'
 
 export const TriggerPlugin = Plugin.create({
     name: 'TriggerPlugin',
-    docs: [createSdkDocEntry('TriggerDefinition', ['sys_hub_trigger_definition'])],
     records: {
         sys_hub_trigger_definition: {
             relationships: {

package/src/flow/plugins/wfa-datapill-plugin.ts

@@ -117,7 +117,6 @@ function extractMetadataFromType(node: ts.Node): {
  */
 export const WfaDataPillPlugin = Plugin.create({
     name: 'WfaDataPillPlugin',
-    docs: [],
     nodes: [
         {
             node: 'CallExpression',

package/src/flow/utils/datapill-transformer.ts

@@ -383,10 +383,14 @@ export function processInstanceForDatapills(
     let configArgIndex: number
 
     if (isFlowLogic) {
-        // For SetFlowVariables and AssignSubflowOutputs, transform the values object (3rd argument)
-        // For ForEach, transform the config (2nd argument)
-        // For other flow logic, transform the config (1st argument)
-        if (callee === FLOW_LOGIC.SET_FLOW_VARIABLES || callee === FLOW_LOGIC.ASSIGN_SUBFLOW_OUTPUTS) {
+        // For SetFlowVariables, AppendToFlowVariables, and AssignSubflowOutputs, transform the values object (3rd
+        // argument). For ForEach, transform the config (2nd argument). For other flow logic, transform the config (1st
+        // argument).
+        if (
+            callee === FLOW_LOGIC.SET_FLOW_VARIABLES ||
+            callee === FLOW_LOGIC.APPEND_TO_FLOW_VARIABLES ||
+            callee === FLOW_LOGIC.ASSIGN_SUBFLOW_OUTPUTS
+        ) {
             configArgIndex = 2
             propsArg = callExpression.getArgument(2)
         } else if (callee === FLOW_LOGIC.FOR_EACH) {
@@ -412,7 +416,11 @@ export function processInstanceForDatapills(
     // The schema argument (arg 1) contains PropertyAccessShape with placeholder identifier (_params)
     // that needs to be resolved to the actual parameter name
     let transformedSchemaArg: Shape | undefined
-    if (callee === FLOW_LOGIC.SET_FLOW_VARIABLES || callee === FLOW_LOGIC.ASSIGN_SUBFLOW_OUTPUTS) {
+    if (
+        callee === FLOW_LOGIC.SET_FLOW_VARIABLES ||
+        callee === FLOW_LOGIC.APPEND_TO_FLOW_VARIABLES ||
+        callee === FLOW_LOGIC.ASSIGN_SUBFLOW_OUTPUTS
+    ) {
         const schemaArg = callExpression.getArgument(1)
         if (schemaArg) {
             const schemaResult = processShapeForDatapills(

package/src/flow/utils/flow-constants.ts

@@ -15,7 +15,6 @@ export const CATALOG_VARIABLE_TABLE = 'item_option_new'
 export const CATALOG_VARIABLE_SET_TABLE = 'io_set_item'
 
 export const UNSUPPORTED_FLOW_DESCENDANTS = [
-    FLOW_STAGE_TABLE,
     PILL_COMPOUND_TABLE,
     TRIGGER_INSTANCE_TABLE,
     ACTION_INSTANCE_TABLE,
@@ -23,6 +22,15 @@ export const UNSUPPORTED_FLOW_DESCENDANTS = [
     FLOW_LOGIC_INSTANCE_TABLE,
 ]
 
+/** Callee name for wfa.stage() calls in the flow body. */
+export const STAGE_API_NAME = 'wfa.stage'
+
+/** Callee name for FlowStage() declarations in the stages config header. */
+export const FLOW_STAGE_CALLEE = 'FlowStage'
+
+/** Default duration written to sys_hub_flow_stage when the developer omits `duration` (zero duration in UTC). */
+export const STAGE_DEFAULT_DURATION = '1970-01-01 00:00:00'
+
 //Plugins callee names
 export const FLOW_API_NAME = 'Flow'
 export const SUBFLOW_API_NAME = 'Subflow'
@@ -35,12 +43,20 @@ export const SUBFLOW_INSTANCE_API_NAME = 'wfa.subflow'
 export const ACTION_STEP_INSTANCE_API_NAME = 'wfa.actionStep'
 export const APPROVAL_RULES_API_NAME = 'wfa.approvalRules'
 export const APPROVAL_DUE_DATE_API_NAME = 'wfa.approvalDueDate'
+export const ASSIGN_ACTION_OUTPUTS_CALLEE = 'wfa.assignActionOutputs'
+export const ERROR_EVALUATION_CALLEE = 'wfa.errorEvaluation'
 
 export const FLOW_OBJECT_API_NAME = 'FlowObject'
 export const FLOW_ARRAY_API_NAME = 'FlowArray'
 
 export const ELEMENT_MAPPING_PROVIDER = 'com.glide.flow_design.action.data.FlowDesignVariableMapper'
 
+// Element mapping table name prefixes — used in sys_element_mapping.table to identify the source
+export const STEP_DEF_INPUT_TABLE_PREFIX = 'var__m_sys_flow_step_definition_input_'
+export const EXT_INPUT_TABLE_PREFIX = 'var__m_sys_hub_step_ext_input_'
+export const EXT_OUTPUT_TABLE_PREFIX = 'var__m_sys_hub_step_ext_output_'
+export const ACTION_OUTPUT_TABLE_PREFIX = 'var__m_sys_hub_action_output_'
+
 const UI_TYPE_LABEL: { [key: string]: string } = {
     string: 'String',
     integer: 'Integer',
@@ -640,6 +656,8 @@ export async function createActionErrorAndStatusRecords(
             order: 2,
             max_length: 40,
             ...props,
+            internal_type: 'boolean',
+            default_value: 'true',
             attributes: getActionOutputAttributes(actionTypeId, 'action_error'),
         },
     })

package/src/flow/utils/flow-io-to-record.ts

@@ -24,7 +24,13 @@ import {
 } from './complex-objects'
 import { getChoiceRecords, getDocumentationRecords } from '../../column/column-to-record'
 
-import { ChoiceDropdown, COLUMN_DEFAULTS, createActionErrorAndStatusRecords } from './flow-constants'
+import {
+    ChoiceDropdown,
+    COLUMN_DEFAULTS,
+    ELEMENT_MAPPING_PROVIDER,
+    createActionErrorAndStatusRecords,
+    getUiTypeLabel,
+} from './flow-constants'
 import { NowIdShape } from '../../now-id-plugin'
 
 /**
@@ -157,16 +163,30 @@ export async function buildVariableRecords(options: {
         } else {
             // Extract attributes from column config if present
             const userAttributes = extractUserAttributes(config)
-            const attributesStr = Object.entries(userAttributes)
-                .map(([key, value]) => `${key}=${value}`)
-                .join(',')
-            additionalProperties['attributes'] = attributesStr
             let internal_type: string
             if (callExpr.getCallee() === GenericColumn.name) {
                 internal_type = config.get('columnType')?.ifString()?.getValue() ?? 'string'
             } else {
                 internal_type = COLUMN_API_TO_TYPE[callExpr.getCallee() as keyof typeof COLUMN_API_TO_TYPE] ?? 'string'
             }
+
+            // For output variables, add element_mapping_provider and related attributes
+            // so Flow Designer knows to resolve datapill values via sys_element_mapping records
+            if (isOutput) {
+                const actionDefId = parentRecord.getId().getValue()
+                const systemAttributes: globalThis.Record<string, string> = {
+                    element_mapping_provider: ELEMENT_MAPPING_PROVIDER,
+                    pwd2droppable: 'true',
+                    uiType: internal_type,
+                    uiTypeLabel: getUiTypeLabel(internal_type),
+                    uiUniqueId: `${actionDefId}-${k}`,
+                }
+                const allAttributes = { ...systemAttributes, ...userAttributes }
+                additionalProperties['attributes'] = formatComplexObjectAttributes(allAttributes)
+            } else {
+                additionalProperties['attributes'] = formatComplexObjectAttributes(userAttributes)
+            }
+
             // Handle reference columns - extract reference table
             if (internal_type === 'reference' || internal_type === 'records') {
                 const referenceTable = config.get('referenceTable')?.ifString()?.getValue()
@@ -223,8 +243,7 @@ export async function buildVariableRecords(options: {
 export function buildVariableShapes(
     variableRecords: Record[],
     descendants: Database,
-    logger?: Logger,
-    snapshotValues?: Map<string, string>
+    logger?: Logger
 ): globalThis.Record<string, CallExpressionShape> | undefined {
     const shapes: globalThis.Record<string, CallExpressionShape> = {}
 
@@ -272,15 +291,12 @@ export function buildVariableShapes(
 
             // Only include $id and co_type_name if NOT deterministically generated
             const schema = JSON.parse(serializedContent)
-            const snapshotValue =
-                snapshotValues?.get(name) ?? variable.get('default_value')?.ifString()?.ifNotEmpty()?.getValue()
             shapes[name] = buildComplexObjectFromSchema(
                 variable,
                 schema,
                 attributes,
                 isDeterministic ? undefined : complexObjectSysId,
-                isDeterministic ? undefined : maybeCoTypeName,
-                snapshotValue
+                isDeterministic ? undefined : maybeCoTypeName
             )
         } else {
             const variableName = variable.get('name').ifString()?.getValue()
@@ -293,8 +309,7 @@ export function buildVariableShapes(
                 variable,
                 additionalProps,
                 descendants,
-                documentation,
-                snapshotValues?.get(name)
+                documentation
             )
         }
     }
@@ -332,8 +347,7 @@ function buildBasicVariableShape(
     variable: Record,
     additionalProps: globalThis.Record<string, unknown>,
     descendants: Database,
-    documentation: Record[],
-    snapshotValue?: string
+    documentation: Record[]
 ) {
     if (callExpressionName === ChoiceColumn.name) {
         // choice column with choices from other table
@@ -407,10 +421,6 @@ function buildBasicVariableShape(
                         .def(choiceDropdown[1]),
                     default: $.from('default_value')
                         .map((value) => {
-                            // Snapshot output value (datapill or static) takes priority
-                            if (snapshotValue !== undefined && snapshotValue !== '') {
-                                return coerceValue(snapshotValue, fieldType)
-                            }
                             const raw = value.isDefined() ? value.getValue() : undefined
                             if (raw === undefined || raw === null || raw === '') {
                                 return undefined