@servicenow/sdk-build-plugins 4.8.0 → 4.8.1

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

@@ -30,7 +30,8 @@ import {
     FLOW_OBJECT_API_NAME,
     FLOW_ARRAY_API_NAME,
 } from '../utils/flow-constants'
-import { normalizeInputValue } from './flow-instance-plugin'
+import { normalizeInputValue, applyTemplateValueSubFieldScripts } from './flow-instance-plugin'
+import { FDInlineScriptCallShape } from './inline-script-plugin'
 import { stripPillType, collectPillTypes } from '../utils/flow-pill-utils'
 import { ApprovalRulesShape, ApprovalDueDateShape } from '../utils/flow-shapes'
 import {
@@ -374,6 +375,9 @@ export const StepInstancePlugin = Plugin.create({
         sys_element_mapping: {
             coalesce: ['field', 'table', 'id'],
         },
+        sys_hub_input_scripts: {
+            coalesce: ['instance', 'input_name'],
+        },
         sys_hub_step_instance: {
             relationships: {
                 sys_variable_value: {
@@ -396,6 +400,10 @@ export const StepInstancePlugin = Plugin.create({
                     via: 'documentkey',
                     descendant: true,
                 },
+                sys_hub_input_scripts: {
+                    via: 'instance',
+                    descendant: true,
+                },
             },
             toShape(record, { descendants, logger }) {
                 // Skip step instances that belong to an action definition —
@@ -491,6 +499,32 @@ export const StepInstancePlugin = Plugin.create({
                         : builtInDef.name
                 }
 
+                // Recover wfa.inlineScript() sub-fields from sys_hub_input_scripts descendants.
+                // Without this, TemplateValue fields with fd-scripted placeholders would round-trip
+                // as TemplateValue({ assignment_group: 'fd-scripted' }) instead of
+                // TemplateValue({ assignment_group: wfa.inlineScript('...') }).
+                const inputScripts = descendants.query('sys_hub_input_scripts')
+                for (const scriptRecord of inputScripts) {
+                    const inputName = scriptRecord.get('input_name')?.asString()?.getValue()
+                    const scriptJson = scriptRecord.get('script')?.asString()?.getValue()
+                    if (!inputName || !scriptJson || configObj[inputName] === undefined) {
+                        continue
+                    }
+                    try {
+                        const scriptedFields = JSON.parse(scriptJson) as globalThis.Record<
+                            string,
+                            { scriptActive: boolean; script: string }
+                        >
+                        configObj[inputName] = applyTemplateValueSubFieldScripts(
+                            configObj[inputName],
+                            scriptedFields,
+                            record
+                        )
+                    } catch {
+                        // malformed script JSON — leave the existing value unchanged
+                    }
+                }
+
                 // Build step instance config (2nd arg): $id, label, error_handling_type
                 const configProperties: globalThis.Record<string, unknown> = {
                     $id: NowIdShape.from(record),
@@ -1079,6 +1113,9 @@ async function createVariableRecords(
             // Handle TemplateValueShape specially - serialize to ServiceNow format.
             // When TemplateValue contains datapills, the platform stores the entire encoded string
             // (with pills inline) in a single sys_element_mapping record with field=<parent input name>.
+            // Scripted sub-fields (wfa.inlineScript()) use the 'fd-scripted' placeholder in the
+            // encoded value and have their script content stored in a sys_hub_input_scripts record.
+            const scriptedSubFields: globalThis.Record<string, { scriptActive: true; script: string }> = {}
             let actualValue: unknown
             if (valueShape.is(TemplateValueShape)) {
                 const templateObj = (valueShape as TemplateValueShape).getTemplateValue()
@@ -1091,6 +1128,10 @@ async function createVariableRecords(
                         collectPillTypes(pillString, pillTypeMap)
                         entries.push(`${field}=${stripPillType(pillString)}`)
                         hasPills = true
+                    } else if (fieldShape instanceof FDInlineScriptCallShape) {
+                        // Use fd-scripted placeholder; script content goes to sys_hub_input_scripts
+                        entries.push(`${field}=fd-scripted`)
+                        scriptedSubFields[field] = { scriptActive: true, script: fieldShape.getScriptContent() }
                     } else if (fieldShape.is(TemplateExpressionShape)) {
                         const resolved = resolveTemplateExpression(
                             fieldShape as TemplateExpressionShape,
@@ -1111,6 +1152,8 @@ async function createVariableRecords(
 
                 const encodedValue = entries.join('^')
 
+                const hasScripts = Object.keys(scriptedSubFields).length > 0
+
                 if (hasPills) {
                     // TemplateValue with datapills → single sys_element_mapping record
                     // No sys_variable_value for this field — platform reads from element_mapping only
@@ -1126,6 +1169,19 @@ async function createVariableRecords(
                             },
                         })
                     )
+                    if (hasScripts) {
+                        allRecords.push(
+                            await factory.createRecord({
+                                source: callExpression,
+                                table: 'sys_hub_input_scripts',
+                                properties: {
+                                    instance: stepInstanceSysId,
+                                    input_name: key,
+                                    script: JSON.stringify(scriptedSubFields),
+                                },
+                            })
+                        )
+                    }
                     return
                 }
 
@@ -1236,6 +1292,22 @@ async function createVariableRecords(
                 },
             })
             allRecords.push(record)
+
+            // For TemplateValue with scripted sub-fields (no datapills path),
+            // create sys_hub_input_scripts record alongside the sys_variable_value
+            if (Object.keys(scriptedSubFields).length > 0) {
+                allRecords.push(
+                    await factory.createRecord({
+                        source: callExpression,
+                        table: 'sys_hub_input_scripts',
+                        properties: {
+                            instance: stepInstanceSysId,
+                            input_name: key,
+                            script: JSON.stringify(scriptedSubFields),
+                        },
+                    })
+                )
+            }
         })
     )
     return allRecords

package/src/flow/post-install.ts

@@ -1,4 +1,4 @@
-import type { PostInstallTask, PostInstallContext } from '@servicenow/sdk-build-core'
+import type { PostInstallTask, PostInstallContext, RecordEntry } from '@servicenow/sdk-build-core'
 
 type ActivateFlowsResult = {
     status: string
@@ -16,8 +16,11 @@ type ActivateFlowsResult = {
     }>
 }
 
+const FLOW_TABLE = 'sys_hub_flow'
+const ACTION_TABLE = 'sys_hub_action_type_definition'
+
 async function activateFlows(context: PostInstallContext): Promise<void> {
-    const { instanceClient, logger, config } = context
+    const { instanceClient, logger, config, recordIds } = context
     const { scopeId } = config
 
     if (!instanceClient) {
@@ -25,13 +28,28 @@ async function activateFlows(context: PostInstallContext): Promise<void> {
         return
     }
 
-    logger.debug('Activating flows...')
+    const flowAndSubflowIds = recordIds?.[FLOW_TABLE] ?? []
+    const actionIds = recordIds?.[ACTION_TABLE] ?? []
+
+    if (flowAndSubflowIds.length === 0 && actionIds.length === 0) {
+        logger.debug('No flows, subflows, or actions found in project, skipping flow activation')
+        return
+    }
+
+    logger.debug(`Activating flows... (${flowAndSubflowIds.length} flow/subflow(s), ${actionIds.length} action(s))`)
 
     const response = await instanceClient.fetch(
         'api/now/wfa_fluent/activate_flows',
         {
             method: 'POST',
-            headers: { Accept: 'application/json' },
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                flows: flowAndSubflowIds,
+                actions: actionIds,
+            }),
         },
         new URLSearchParams({ sysparm_transaction_scope: scopeId })
     )
@@ -40,7 +58,7 @@ async function activateFlows(context: PostInstallContext): Promise<void> {
     // Any other non-OK status (400, 401, 403, 500, etc.) is an error
     if (!response.ok && response.status !== 422) {
         const body = await response.json().catch(() => null)
-        const msg = body?.error?.message ?? body?.message ?? response.statusText
+        const msg = body?.result?.error?.message ?? body?.error?.message ?? body?.message ?? response.statusText
 
         // Instances without the endpoint return 400 with "does not represent any resource"
         if (msg.includes('does not represent any resource')) {
@@ -84,6 +102,19 @@ async function activateFlows(context: PostInstallContext): Promise<void> {
     logger.warn(msg)
 }
 
+export function getRecordIdsByTable(keysRegistry: Now.Internal.KeysRegistry): Record<string, RecordEntry[]> {
+    const result: Record<string, RecordEntry[]> = {}
+
+    for (const entry of Object.values(keysRegistry.explicit)) {
+        if (entry.deleted) {
+            continue
+        }
+        const entries = (result[entry.table] ??= [])
+        entries.push({ sys_id: entry.id, active: '', state: '' })
+    }
+    return result
+}
+
 export const FlowActivationTask: PostInstallTask = {
     name: 'flow-activation',
     skipFlag: 'skipFlowActivation',

package/src/flow/utils/complex-object-resolver.ts

@@ -850,8 +850,10 @@ function buildCv(typeNode: unknown, valueNode: unknown): unknown {
         // Special handling for primitive arrays (schema: ["Any"], value: ["item1", "item2", ...])
         if (Array.isArray(typeNode) && Array.isArray(valueNode)) {
             if (typeNode.length === 1 && typeNode[0] === 'Any') {
-                // Primitive array: return plain string values without $cv wrapping
-                return valueNode.map((v) => String(v))
+                // Primitive array: preserve native types (string, number, boolean) without $cv wrapping.
+                // Do NOT force String(v) — that would convert [10,20,30] to ['10','20','30'] and
+                // [true,false] to ['true','false'], breaking the round-trip for IntegerColumn/BooleanColumn.
+                return valueNode
             }
         }
 

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

@@ -5,11 +5,18 @@ import {
     Shape,
     VariableStatementShape,
     ObjectShape,
+    gunzipSync,
     type Diagnostics,
     type Logger,
 } from '@servicenow/sdk-build-core'
 import { ArrowFunctionShape } from '../../arrow-function-plugin'
-import { FLOW_LOGIC, FLOW_LOGIC_PREFIX } from '../flow-logic/flow-logic-constants'
+import {
+    DO_IN_PARALLEL_BLOCK_SYS_ID,
+    FLOW_LOGIC,
+    FLOW_LOGIC_PREFIX,
+    FLOW_LOGIC_SYS_ID_MAP,
+    TRY_CATCH_CATCH_SYS_ID,
+} from '../flow-logic/flow-logic-constants'
 
 /**
  * Result of datapill transformation
@@ -22,7 +29,7 @@ export interface DatapillTransformResult {
 /**
  * Information about a flow instance shape for processing
  */
-export interface FlowInstanceShapeInfo {
+interface FlowInstanceShapeInfo {
     callExpression: CallExpressionShape
     variableStatement: VariableStatementShape | CallExpressionShape
 }
@@ -57,7 +64,7 @@ export function buildUuidToIdentifierMap(recordToShapeMap: Map<Record, Shape>):
 
     for (const [record, instanceShape] of recordToShapeMap.entries()) {
         // Extract ui_id from the record (this is what datapills reference)
-        const uiId = record.get('ui_id')?.getValue() as string | undefined
+        const uiId = record.get('ui_id')?.ifString()?.getValue()
 
         if (!uiId) {
             continue
@@ -66,6 +73,14 @@ export function buildUuidToIdentifierMap(recordToShapeMap: Map<Record, Shape>):
         // Handle VariableStatementShape (actions/subflows with variable assignments)
         if (instanceShape instanceof VariableStatementShape) {
             const variableStatement = instanceShape.as(VariableStatementShape)
+            const initCallee =
+                variableStatement.getInitializer() instanceof CallExpressionShape
+                    ? (variableStatement.getInitializer() as CallExpressionShape).getCallee()
+                    : undefined
+            if (initCallee === FLOW_LOGIC.DO_IN_PARALLEL || initCallee === FLOW_LOGIC.TRY_CATCH) {
+                continue
+            }
+
             const variableName = variableStatement.getVariableName()
             const callExpression = variableStatement.getInitializer().as(CallExpressionShape)
 
@@ -119,6 +134,227 @@ export function buildUuidToIdentifierMap(recordToShapeMap: Map<Record, Shape>):
     return uuidToIdentifierMap
 }
 
+/**
+ * Build a ui_id → ancestor-chain map for the given instances. Each entry's value is the set of all `ui_id`s in the
+ * record's ancestor chain, including the record itself. Useful when resolving pills: a source record that lives
+ * "inside the same branch" as the target action shares the target's branch `ui_id` in this set, and the bare
+ * identifier can be used (no outer-binding dot-walk needed).
+ */
+function buildAncestorChainMap(allInstances: ReadonlyArray<Record>): Map<string, Set<string>> {
+    const recordByUiId = new Map<string, Record>()
+
+    for (const inst of allInstances) {
+        const ui = inst.get('ui_id')?.ifString()?.getValue()
+        if (ui) {
+            recordByUiId.set(ui, inst)
+        }
+    }
+
+    const chainByUiId = new Map<string, Set<string>>()
+
+    const computeChain = (uiId: string, seen: Set<string>): Set<string> => {
+        const cached = chainByUiId.get(uiId)
+        if (cached) {
+            return cached
+        }
+
+        if (seen.has(uiId)) {
+            return new Set([uiId]) // Cycle guard.
+        }
+
+        seen.add(uiId)
+
+        const chain = new Set<string>([uiId])
+        const rec = recordByUiId.get(uiId)
+        const parent = rec?.get('parent_ui_id')?.ifString()?.getValue()
+        if (parent) {
+            for (const ancestor of computeChain(parent, seen)) {
+                chain.add(ancestor)
+            }
+        }
+
+        chainByUiId.set(uiId, chain)
+        return chain
+    }
+
+    for (const inst of allInstances) {
+        const ui = inst.get('ui_id')?.ifString()?.getValue()
+        if (ui) {
+            computeChain(ui, new Set())
+        }
+    }
+
+    return chainByUiId
+}
+
+/**
+ * Detect whether any action/subflow nested inside a DoInParallel branch or TryCatch arm has its output
+ * referenced from outside that branch/arm. Returns true if hoisting is detected (caller should fall back
+ * to Record() API), false otherwise.
+ */
+export function detectHoistedOutputBindings(allInstances: ReadonlyArray<Record>): boolean {
+    if (allInstances.length === 0) {
+        return false
+    }
+
+    const tryCatchLogicId = FLOW_LOGIC_SYS_ID_MAP[FLOW_LOGIC.TRY_CATCH]
+
+    // Collect ui_ids of all DoInParallel branches and TryCatch arms.
+    const branchUiIds = new Set<string>()
+    for (const inst of allInstances) {
+        if (inst.getTable() !== 'sys_hub_flow_logic_instance_v2') {
+            continue
+        }
+        const logicDef = inst.get('logic_definition')?.ifString()?.getValue()
+        if (
+            logicDef === DO_IN_PARALLEL_BLOCK_SYS_ID ||
+            logicDef === TRY_CATCH_CATCH_SYS_ID ||
+            (tryCatchLogicId && logicDef === tryCatchLogicId)
+        ) {
+            const uiId = inst.get('ui_id')?.ifString()?.getValue()
+            if (uiId) {
+                branchUiIds.add(uiId)
+            }
+        }
+    }
+
+    if (branchUiIds.size === 0) {
+        return false
+    }
+
+    // Build ancestor chain map and reference index.
+    const ancestorChainMap = buildAncestorChainMap(allInstances)
+    const referenceIndex = buildReferenceIndex(allInstances)
+
+    // Map: action/subflow UUID → the branch/arm ui_id that contains it (directly or transitively).
+    // Uses the full ancestor chain so actions nested inside If/ForEach within a branch are also caught.
+    const innerActionBranch = new Map<string, string>()
+    for (const [uuid, record] of uuidToRecordMap.entries()) {
+        const uiId = record.get('ui_id')?.ifString()?.getValue()
+        if (!uiId) {
+            continue
+        }
+        const chain = ancestorChainMap.get(uiId)
+        if (!chain) {
+            continue
+        }
+        for (const branchUiId of branchUiIds) {
+            if (chain.has(branchUiId)) {
+                innerActionBranch.set(uuid, branchUiId)
+                break
+            }
+        }
+    }
+
+    if (innerActionBranch.size === 0) {
+        return false
+    }
+
+    // For each inner action UUID, check if any source record referencing it lives outside its branch.
+    for (const [uuid, branchUiId] of innerActionBranch.entries()) {
+        const sources = referenceIndex.get(uuid)
+        if (!sources) {
+            continue
+        }
+
+        for (const sourceUiId of sources) {
+            if (!sourceUiId) {
+                continue
+            }
+            const ancestorChain = ancestorChainMap.get(sourceUiId)
+            const isInside = ancestorChain ? ancestorChain.has(branchUiId) : false
+            if (!isInside) {
+                return true
+            }
+        }
+    }
+
+    return false
+}
+
+function buildReferenceIndex(allInstances: ReadonlyArray<Record>): Map<string, Set<string | undefined>> {
+    const result = new Map<string, Set<string | undefined>>()
+    const uuidRe = /\{\{(?:step\[)?([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/g
+    for (const inst of allInstances) {
+        const valuesStr = readValuesForPillScan(inst)
+        if (!valuesStr) {
+            continue
+        }
+
+        const sourceUiId = inst.get('ui_id')?.ifString()?.getValue()
+        for (const m of valuesStr.matchAll(uuidRe)) {
+            const uuid = m[1]
+            if (!uuid) {
+                continue
+            }
+
+            let sources = result.get(uuid)
+            if (!sources) {
+                sources = new Set<string | undefined>()
+                result.set(uuid, sources)
+            }
+
+            sources.add(sourceUiId)
+        }
+    }
+    return result
+}
+
+/**
+ * Read an instance record's `values` column for substring-search of datapill UUIDs. ServiceNow stores the values field
+ * as a gzipped+base64 string. Returns the decompressed JSON-stringified payload, or `undefined` if the column is
+ * missing / unreadable. Errors are swallowed because pill-scan failure is non-critical — the worst case is
+ * over-keeping a binding.
+ */
+// Memoizes the decoded `values` column per record. Decoding gzips (via `gunzipSync`) which is expensive, and the same
+// records are scanned repeatedly — once by `buildReferenceIndex`, once per catch arm in `buildCatchParamMap`, etc.
+// Keyed by Record identity (WeakMap), so entries are collected once a flow's records go out of scope.
+const valuesScanCache = new WeakMap<Record, string | undefined>()
+
+function readValuesForPillScan(record: Record): string | undefined {
+    const cached = valuesScanCache.get(record)
+    if (cached !== undefined || valuesScanCache.has(record)) {
+        return cached
+    }
+
+    const decoded = decodeValuesForPillScan(record)
+    valuesScanCache.set(record, decoded)
+
+    return decoded
+}
+
+function decodeValuesForPillScan(record: Record): string | undefined {
+    const raw = record.get('values')?.getValue()
+    if (raw === undefined || raw === null) {
+        return undefined
+    }
+
+    if (typeof raw !== 'string') {
+        // Already deserialized — stringify so callers can do substring search.
+        try {
+            return JSON.stringify(raw)
+        } catch {
+            return undefined
+        }
+    }
+
+    if (raw === '') {
+        return ''
+    }
+
+    // gzip magic bytes are `H4sI` when base64-encoded. `gunzipSync` (fflate) takes/returns a Uint8Array, so decode the
+    // base64 to bytes on the way in and back to utf8 on the way out.
+    if (raw.startsWith('H4sI')) {
+        try {
+            return Buffer.from(gunzipSync(Buffer.from(raw, 'base64'))).toString('utf8')
+        } catch {
+            return undefined
+        }
+    }
+
+    return raw
+}
+
 /**
  * Extract CallExpression and VariableStatement from an instance shape
  * Handles both VariableStatementShape (for Action/Subflow) and bare CallExpressionShape (for flow logic)
@@ -126,7 +362,7 @@ export function buildUuidToIdentifierMap(recordToShapeMap: Map<Record, Shape>):
  * @param instanceShape - The shape to extract from
  * @returns Object containing callExpression and variableStatement
  */
-export function extractInstanceShapeInfo(instanceShape: Shape): FlowInstanceShapeInfo {
+function extractInstanceShapeInfo(instanceShape: Shape): FlowInstanceShapeInfo {
     let callExpression: CallExpressionShape
     let variableStatement: VariableStatementShape | CallExpressionShape
 
@@ -141,32 +377,6 @@ export function extractInstanceShapeInfo(instanceShape: Shape): FlowInstanceShap
     return { callExpression, variableStatement }
 }
 
-/**
- * Rebuild a CallExpressionShape with transformed properties
- * Creates a new CallExpression with the transformed props and cleaned config
- *
- * @param originalCallExpression - The original CallExpression
- * @param transformedProps - The transformed properties object
- * @param configShape - The config shape (possibly cleaned)
- * @param record - The source record for shape creation
- * @returns New CallExpressionShape with transformed properties
- */
-export function rebuildCallExpressionWithDatapills(
-    originalCallExpression: CallExpressionShape,
-    transformedProps: { [key: string]: Shape },
-    configShape: Shape,
-    record: Record
-): CallExpressionShape {
-    const originalActionDef = originalCallExpression.getArgument(0, false)
-    const newPropsArg = Shape.from(record, transformedProps)
-
-    return new CallExpressionShape({
-        source: originalCallExpression.getSource(),
-        callee: originalCallExpression.getCallee(),
-        args: [originalActionDef, configShape, newPropsArg],
-    })
-}
-
 /**
  * Rebuild an instance shape (VariableStatement or CallExpression) with transformed datapills
  *
@@ -175,7 +385,7 @@ export function rebuildCallExpressionWithDatapills(
  * @param instanceShapeInfo - Information extracted from the instance shape
  * @returns Rebuilt VariableStatementShape or the new CallExpression
  */
-export function rebuildInstanceWithDatapills(
+function rebuildInstanceWithDatapills(
     instanceShape: Shape,
     newCallExpression: CallExpressionShape,
     instanceShapeInfo: FlowInstanceShapeInfo
@@ -203,7 +413,7 @@ export function rebuildInstanceWithDatapills(
  * @param callee - The callee string (e.g., 'wfa.flowLogic.if', 'wfa.action')
  * @returns true if the callee is a flow logic call
  */
-export function isFlowLogicCallee(callee: string): boolean {
+function isFlowLogicCallee(callee: string): boolean {
     return callee.startsWith(FLOW_LOGIC_PREFIX)
 }
 
@@ -212,7 +422,7 @@ export function isFlowLogicCallee(callee: string): boolean {
  * @param callee - The flow logic callee (e.g., 'wfa.flowLogic.if')
  * @returns true if the flow logic has a body
  */
-export function flowLogicHasBody(callee: string): boolean {
+function flowLogicHasBody(callee: string): boolean {
     // Flow logic with bodies: if, elseIf, else, forEach, tryCatch, doInParallel
     // Flow logic without bodies: goBackTo, waitForADuration, exitLoop, endFlow, skipIteration
     return [
@@ -237,7 +447,7 @@ export function flowLogicHasBody(callee: string): boolean {
  * @param callee - The flow logic callee
  * @returns Array of arrow function shapes
  */
-export function extractFlowLogicBodies(callExpression: CallExpressionShape, callee: string): ArrowFunctionShape[] {
+function extractFlowLogicBodies(callExpression: CallExpressionShape, callee: string): ArrowFunctionShape[] {
     const bodies: ArrowFunctionShape[] = []
 
     if (callee === FLOW_LOGIC.TRY_CATCH) {
@@ -288,7 +498,7 @@ export function extractFlowLogicBodies(callExpression: CallExpressionShape, call
  * @param record - The source record
  * @returns Rebuilt CallExpressionShape
  */
-export function rebuildFlowLogicWithDatapills(
+function rebuildFlowLogicWithDatapills(
     callExpression: CallExpressionShape,
     transformedConfig: ObjectShape,
     transformedBodies: ArrowFunctionShape[],
@@ -544,12 +754,14 @@ export function processInstanceForDatapills(
                 }
             }
 
-            // Rebuild body if children changed
+            // Rebuild body if children changed. Preserve the arrow's `returnValue` if present.
+            const returnValue = body.getReturnValue()
             const transformedBody = anyChildChanged
                 ? new ArrowFunctionShape({
                       source: body.getSource(),
                       parameters: body.getParameters(),
                       statements: transformedChildren,
+                      ...(returnValue !== undefined && { returnValue }),
                   })
                 : body
 

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

@@ -194,6 +194,16 @@ export async function buildVariableRecords(options: {
                     additionalProperties['reference'] = referenceTable
                 }
             }
+
+            // Handle field_list and template_value columns - extract dependent field.
+            // Always write all three fields so that removing 'dependent' from fluent
+            // explicitly clears the old value in ServiceNow rather than leaving it stale.
+            if (internal_type === 'field_list' || internal_type === 'template_value') {
+                const dependent = config.get('dependent')?.ifString()?.getValue() ?? ''
+                additionalProperties['dependent'] = dependent
+                additionalProperties['dependent_on_field'] = dependent
+                additionalProperties['use_dependent_field'] = dependent !== ''
+            }
             additionalProperties['internal_type'] = internal_type
             additionalProperties['max_length'] =
                 config.get('maxLength')?.ifNumber()?.getValue() ?? getDefaultMaxLength(internal_type)
@@ -400,7 +410,11 @@ function buildBasicVariableShape(
     // Add dependent field for template_value and field_list column types
     if (fieldType === 'template_value' || fieldType === 'field_list') {
         const dependent = variable.get('dependent')?.ifString()?.getValue()
-        additionalProps['dependent'] = dependent ?? ''
+        // For field_list, dependent is optional — only emit it when non-empty.
+        // For template_value, dependent is required by its type, so always include it.
+        if (fieldType === 'template_value' || dependent) {
+            additionalProps['dependent'] = dependent ?? ''
+        }
     }
 
     return new CallExpressionShape({
@@ -521,7 +535,7 @@ function validateAndPopulateChoiceProperties(
     }
 
     // Default to dropdown_with_none
-    let choiceValue = ChoiceDropdown.DROPDOWN_WITHOUT_NONE
+    let choiceValue = ChoiceDropdown.DROPDOWN_WITH_NONE
 
     // Handle dropdown type configuration
     const defaultValue = config.get('default')
@@ -531,23 +545,23 @@ function validateAndPopulateChoiceProperties(
         const choiceTypeValue = choiceTypeNode.getValue() as choiceDropdownType
         const choiceDropdownValue = choiceDropdown.indexOf(choiceTypeValue)
 
-        if (choiceDropdownValue === ChoiceDropdown.DROPDOWN_WITHOUT_NONE) {
-            // Validate default value exists for dropdown_without_none
-            if (defaultValue.isUndefined()) {
-                diagnostics.error(config, 'Default value is required for dropdown type "dropdown_without_none"')
-                return
-            }
-            choiceValue = ChoiceDropdown.DROPDOWN_WITHOUT_NONE
-        } else if (choiceDropdownValue !== ChoiceDropdown.DROPDOWN_WITH_NONE) {
-            // Only dropdown_with_none and dropdown_without_none are valid
+        if (choiceDropdownValue === -1) {
+            // Not a recognized dropdown type
             diagnostics.error(
                 choiceTypeNode,
-                'Invalid dropdown type, expected "dropdown_with_none" or "dropdown_without_none"'
+                `Invalid dropdown type "${choiceTypeValue}", expected one of: ${choiceDropdown.join(', ')}`
             )
             return
-        } else {
-            choiceValue = choiceDropdownValue
         }
+
+        // dropdown_without_none has no "--None--" entry, so a default value is required
+        if (choiceDropdownValue === ChoiceDropdown.DROPDOWN_WITHOUT_NONE && defaultValue.isUndefined()) {
+            diagnostics.error(config, 'Default value is required for dropdown type "dropdown_without_none"')
+            return
+        }
+
+        // Preserve whatever valid dropdown type came through (none/with_none/suggestion/without_none)
+        choiceValue = choiceDropdownValue
     }
 
     // Set the choice value